home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / lib / python2.4 / sre_compile.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2005-10-18  |  11KB  |  481 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.4)
  3.  
  4. '''Internal support module for sre'''
  5. import _sre
  6. import sys
  7. from sre_constants import *
  8. if _sre.CODESIZE == 2:
  9.     MAXCODE = 65535
  10. else:
  11.     MAXCODE = 0xFFFFFFFFL
  12.  
  13. def _identityfunction(x):
  14.     return x
  15.  
  16.  
  17. def _compile(code, pattern, flags):
  18.     emit = code.append
  19.     _len = len
  20.     LITERAL_CODES = {
  21.         LITERAL: 1,
  22.         NOT_LITERAL: 1 }
  23.     REPEATING_CODES = {
  24.         REPEAT: 1,
  25.         MIN_REPEAT: 1,
  26.         MAX_REPEAT: 1 }
  27.     SUCCESS_CODES = {
  28.         SUCCESS: 1,
  29.         FAILURE: 1 }
  30.     ASSERT_CODES = {
  31.         ASSERT: 1,
  32.         ASSERT_NOT: 1 }
  33.     for op, av in pattern:
  34.         if op in LITERAL_CODES:
  35.             if flags & SRE_FLAG_IGNORECASE:
  36.                 emit(OPCODES[OP_IGNORE[op]])
  37.                 emit(_sre.getlower(av, flags))
  38.             else:
  39.                 emit(OPCODES[op])
  40.                 emit(av)
  41.         flags & SRE_FLAG_IGNORECASE
  42.         None if op is IN else flags & SRE_FLAG_DOTALL
  43.         if op in REPEATING_CODES:
  44.             if flags & SRE_FLAG_TEMPLATE:
  45.                 raise error, 'internal: unsupported template operator'
  46.                 emit(OPCODES[REPEAT])
  47.                 skip = _len(code)
  48.                 emit(0)
  49.                 emit(av[0])
  50.                 emit(av[1])
  51.                 _compile(code, av[2], flags)
  52.                 emit(OPCODES[SUCCESS])
  53.                 code[skip] = _len(code) - skip
  54.             elif _simple(av) and op is not REPEAT:
  55.                 if op is MAX_REPEAT:
  56.                     emit(OPCODES[REPEAT_ONE])
  57.                 else:
  58.                     emit(OPCODES[MIN_REPEAT_ONE])
  59.                 skip = _len(code)
  60.                 emit(0)
  61.                 emit(av[0])
  62.                 emit(av[1])
  63.                 _compile(code, av[2], flags)
  64.                 emit(OPCODES[SUCCESS])
  65.                 code[skip] = _len(code) - skip
  66.             else:
  67.                 emit(OPCODES[REPEAT])
  68.                 skip = _len(code)
  69.                 emit(0)
  70.                 emit(av[0])
  71.                 emit(av[1])
  72.                 _compile(code, av[2], flags)
  73.                 code[skip] = _len(code) - skip
  74.                 if op is MAX_REPEAT:
  75.                     emit(OPCODES[MAX_UNTIL])
  76.                 else:
  77.                     emit(OPCODES[MIN_UNTIL])
  78.         op is MAX_REPEAT
  79.         if op is SUBPATTERN:
  80.             if av[0]:
  81.                 emit(OPCODES[MARK])
  82.                 emit((av[0] - 1) * 2)
  83.             
  84.             _compile(code, av[1], flags)
  85.             if av[0]:
  86.                 emit(OPCODES[MARK])
  87.                 emit((av[0] - 1) * 2 + 1)
  88.             
  89.         av[0]
  90.         if op in SUCCESS_CODES:
  91.             emit(OPCODES[op])
  92.             continue
  93.         if op in ASSERT_CODES:
  94.             emit(OPCODES[op])
  95.             skip = _len(code)
  96.             emit(0)
  97.             if av[0] >= 0:
  98.                 emit(0)
  99.             else:
  100.                 (lo, hi) = av[1].getwidth()
  101.                 if lo != hi:
  102.                     raise error, 'look-behind requires fixed-width pattern'
  103.                 
  104.                 emit(lo)
  105.             _compile(code, av[1], flags)
  106.             emit(OPCODES[SUCCESS])
  107.             code[skip] = _len(code) - skip
  108.             continue
  109.         if op is CALL:
  110.             emit(OPCODES[op])
  111.             skip = _len(code)
  112.             emit(0)
  113.             _compile(code, av, flags)
  114.             emit(OPCODES[SUCCESS])
  115.             code[skip] = _len(code) - skip
  116.             continue
  117.         if op is AT:
  118.             emit(OPCODES[op])
  119.             if flags & SRE_FLAG_MULTILINE:
  120.                 av = AT_MULTILINE.get(av, av)
  121.             
  122.             if flags & SRE_FLAG_LOCALE:
  123.                 av = AT_LOCALE.get(av, av)
  124.             elif flags & SRE_FLAG_UNICODE:
  125.                 av = AT_UNICODE.get(av, av)
  126.             
  127.             emit(ATCODES[av])
  128.             continue
  129.         if op is BRANCH:
  130.             emit(OPCODES[op])
  131.             tail = []
  132.             tailappend = tail.append
  133.             for av in av[1]:
  134.                 skip = _len(code)
  135.                 emit(0)
  136.                 _compile(code, av, flags)
  137.                 emit(OPCODES[JUMP])
  138.                 tailappend(_len(code))
  139.                 emit(0)
  140.                 code[skip] = _len(code) - skip
  141.             
  142.             emit(0)
  143.             for tail in tail:
  144.                 code[tail] = _len(code) - tail
  145.             
  146.         if op is CATEGORY:
  147.             emit(OPCODES[op])
  148.             if flags & SRE_FLAG_LOCALE:
  149.                 av = CH_LOCALE[av]
  150.             elif flags & SRE_FLAG_UNICODE:
  151.                 av = CH_UNICODE[av]
  152.             
  153.             emit(CHCODES[av])
  154.             continue
  155.         None if op is GROUPREF else av[2]
  156.         raise ValueError, ('unsupported operand type', op)
  157.     
  158.  
  159.  
  160. def _compile_charset(charset, flags, code, fixup = None):
  161.     emit = code.append
  162.     if fixup is None:
  163.         fixup = _identityfunction
  164.     
  165.     for op, av in _optimize_charset(charset, fixup):
  166.         emit(OPCODES[op])
  167.         if op is NEGATE:
  168.             continue
  169.         if op is LITERAL:
  170.             emit(fixup(av))
  171.             continue
  172.         if op is RANGE:
  173.             emit(fixup(av[0]))
  174.             emit(fixup(av[1]))
  175.             continue
  176.         if op is CHARSET:
  177.             code.extend(av)
  178.             continue
  179.         None if op is BIGCHARSET else flags & SRE_FLAG_LOCALE
  180.         raise error, 'internal: unsupported set operator'
  181.     
  182.     emit(OPCODES[FAILURE])
  183.  
  184.  
  185. def _optimize_charset(charset, fixup):
  186.     out = []
  187.     outappend = out.append
  188.     charmap = [
  189.         0] * 256
  190.     
  191.     try:
  192.         for op, av in charset:
  193.             if op is NEGATE:
  194.                 outappend((op, av))
  195.                 continue
  196.             if op is LITERAL:
  197.                 charmap[fixup(av)] = 1
  198.                 continue
  199.             if op is RANGE:
  200.                 for i in range(fixup(av[0]), fixup(av[1]) + 1):
  201.                     charmap[i] = 1
  202.                 
  203.             if op is CATEGORY:
  204.                 return charset
  205.                 continue
  206.     except IndexError:
  207.         return _optimize_unicode(charset, fixup)
  208.  
  209.     i = p = n = 0
  210.     runs = []
  211.     runsappend = runs.append
  212.     for c in charmap:
  213.         if c:
  214.             if n == 0:
  215.                 p = i
  216.             
  217.             n = n + 1
  218.         elif n:
  219.             runsappend((p, n))
  220.             n = 0
  221.         
  222.         i = i + 1
  223.     
  224.     if n:
  225.         runsappend((p, n))
  226.     
  227.     if len(runs) <= 2:
  228.         for p, n in runs:
  229.             if n == 1:
  230.                 outappend((LITERAL, p))
  231.                 continue
  232.             outappend((RANGE, (p, p + n - 1)))
  233.         
  234.         if len(out) < len(charset):
  235.             return out
  236.         
  237.     else:
  238.         data = _mk_bitmap(charmap)
  239.         outappend((CHARSET, data))
  240.         return out
  241.     return charset
  242.  
  243.  
  244. def _mk_bitmap(bits):
  245.     data = []
  246.     dataappend = data.append
  247.     if _sre.CODESIZE == 2:
  248.         start = (1, 0)
  249.     else:
  250.         start = (0x1L, 0x0L)
  251.     (m, v) = start
  252.     for c in bits:
  253.         if c:
  254.             v = v + m
  255.         
  256.         m = m + m
  257.         if m > MAXCODE:
  258.             dataappend(v)
  259.             (m, v) = start
  260.             continue
  261.     
  262.     return data
  263.  
  264.  
  265. def _optimize_unicode(charset, fixup):
  266.     
  267.     try:
  268.         import array as array
  269.     except ImportError:
  270.         return charset
  271.  
  272.     charmap = [
  273.         0] * 65536
  274.     negate = 0
  275.     
  276.     try:
  277.         for op, av in charset:
  278.             if op is NEGATE:
  279.                 negate = 1
  280.                 continue
  281.             if op is LITERAL:
  282.                 charmap[fixup(av)] = 1
  283.                 continue
  284.             if op is RANGE:
  285.                 for i in xrange(fixup(av[0]), fixup(av[1]) + 1):
  286.                     charmap[i] = 1
  287.                 
  288.             if op is CATEGORY:
  289.                 return charset
  290.                 continue
  291.     except IndexError:
  292.         return charset
  293.  
  294.     if negate:
  295.         if sys.maxunicode != 65535:
  296.             return charset
  297.         
  298.         for i in xrange(65536):
  299.             charmap[i] = not charmap[i]
  300.         
  301.     
  302.     comps = { }
  303.     mapping = [
  304.         0] * 256
  305.     block = 0
  306.     data = []
  307.     for i in xrange(256):
  308.         chunk = tuple(charmap[i * 256:(i + 1) * 256])
  309.         new = comps.setdefault(chunk, block)
  310.         mapping[i] = new
  311.         if new == block:
  312.             block = block + 1
  313.             data = data + _mk_bitmap(chunk)
  314.             continue
  315.     
  316.     header = [
  317.         block]
  318.     if _sre.CODESIZE == 2:
  319.         code = 'H'
  320.     else:
  321.         code = 'I'
  322.     mapping = array.array('b', mapping).tostring()
  323.     mapping = array.array(code, mapping)
  324.     header = header + mapping.tolist()
  325.     data[0:0] = header
  326.     return [
  327.         (BIGCHARSET, data)]
  328.  
  329.  
  330. def _simple(av):
  331.     (lo, hi) = av[2].getwidth()
  332.     if lo == 0 and hi == MAXREPEAT:
  333.         raise error, 'nothing to repeat'
  334.     
  335.     return None if hi == hi else av[2][0][0] != SUBPATTERN
  336.  
  337.  
  338. def _compile_info(code, pattern, flags):
  339.     (lo, hi) = pattern.getwidth()
  340.     if lo == 0:
  341.         return None
  342.     
  343.     prefix = []
  344.     prefixappend = prefix.append
  345.     prefix_skip = 0
  346.     charset = []
  347.     charsetappend = charset.append
  348.     if not flags & SRE_FLAG_IGNORECASE:
  349.         for op, av in pattern.data:
  350.             None if op is LITERAL else op is LITERAL
  351.             break
  352.         
  353.         if not prefix and pattern.data:
  354.             (op, av) = pattern.data[0]
  355.             if op is SUBPATTERN and av[1]:
  356.                 (op, av) = av[1][0]
  357.                 if op is LITERAL:
  358.                     charsetappend((op, av))
  359.                 elif op is BRANCH:
  360.                     c = []
  361.                     cappend = c.append
  362.                     for p in av[1]:
  363.                         if not p:
  364.                             break
  365.                         
  366.                         (op, av) = p[0]
  367.                         if op is LITERAL:
  368.                             cappend((op, av))
  369.                             continue
  370.                         break
  371.                     else:
  372.                         charset = c
  373.                 
  374.             elif op is BRANCH:
  375.                 c = []
  376.                 cappend = c.append
  377.                 for p in av[1]:
  378.                     if not p:
  379.                         break
  380.                     
  381.                     (op, av) = p[0]
  382.                     if op is LITERAL:
  383.                         cappend((op, av))
  384.                         continue
  385.                     break
  386.                 else:
  387.                     charset = c
  388.             elif op is IN:
  389.                 charset = av
  390.             
  391.         
  392.     
  393.     emit = code.append
  394.     emit(OPCODES[INFO])
  395.     skip = len(code)
  396.     emit(0)
  397.     mask = 0
  398.     if prefix:
  399.         mask = SRE_INFO_PREFIX
  400.         if prefix_skip == prefix_skip:
  401.             pass
  402.         elif prefix_skip == len(pattern.data):
  403.             mask = mask + SRE_INFO_LITERAL
  404.         
  405.     elif charset:
  406.         mask = mask + SRE_INFO_CHARSET
  407.     
  408.     emit(mask)
  409.     if lo < MAXCODE:
  410.         emit(lo)
  411.     else:
  412.         emit(MAXCODE)
  413.         prefix = prefix[:MAXCODE]
  414.     if hi < MAXCODE:
  415.         emit(hi)
  416.     else:
  417.         emit(0)
  418.     if prefix:
  419.         emit(len(prefix))
  420.         emit(prefix_skip)
  421.         code.extend(prefix)
  422.         table = [
  423.             -1] + [
  424.             0] * len(prefix)
  425.         for i in xrange(len(prefix)):
  426.             table[i + 1] = table[i] + 1
  427.             while table[i + 1] > 0 and prefix[i] != prefix[table[i + 1] - 1]:
  428.                 table[i + 1] = table[table[i + 1] - 1] + 1
  429.         
  430.         code.extend(table[1:])
  431.     elif charset:
  432.         _compile_charset(charset, flags, code)
  433.     
  434.     code[skip] = len(code) - skip
  435.  
  436.  
  437. try:
  438.     unicode
  439. except NameError:
  440.     STRING_TYPES = (type(''),)
  441.  
  442. STRING_TYPES = (type(''), type(unicode('')))
  443.  
  444. def isstring(obj):
  445.     for tp in STRING_TYPES:
  446.         if isinstance(obj, tp):
  447.             return 1
  448.             continue
  449.     
  450.     return 0
  451.  
  452.  
  453. def _code(p, flags):
  454.     flags = p.pattern.flags | flags
  455.     code = []
  456.     _compile_info(code, p, flags)
  457.     _compile(code, p.data, flags)
  458.     code.append(OPCODES[SUCCESS])
  459.     return code
  460.  
  461.  
  462. def compile(p, flags = 0):
  463.     if isstring(p):
  464.         import sre_parse as sre_parse
  465.         pattern = p
  466.         p = sre_parse.parse(p, flags)
  467.     else:
  468.         pattern = None
  469.     code = _code(p, flags)
  470.     if p.pattern.groups > 100:
  471.         raise AssertionError('sorry, but this version only supports 100 named groups')
  472.     
  473.     groupindex = p.pattern.groupdict
  474.     indexgroup = [
  475.         None] * p.pattern.groups
  476.     for k, i in groupindex.items():
  477.         indexgroup[i] = k
  478.     
  479.     return _sre.compile(pattern, flags, code, p.pattern.groups - 1, groupindex, indexgroup)
  480.  
  481.